package cz.pecinovsky.česky.oopnz._134_;
//Příliš žluťoučký kůň úpěl ďábelské ódy

//import cz.pecinovsky.česky.oopnz._000_.Run;

//import cz.pecinovsky.česky.oopnz.utility.IO;


//import static cz.pecinovsky.česky.oopnz._134_.ZrnitostHodinCykly_143_.ZrnitostHodinCykly;
////////////////////////////////////////////////////////////////////////////////
//%%+  +++++ Konec ignorovaného počátečního textu +++++
//%X+ xxxxx Začátek přeskakovaného textu xxxxx
/*******************************************************************************
 *<pre>
 * Předchozí:   Není - toto_je_nově_definovaná_třída
 *              Ttt v projektu Ppp
 * Následující: Prozatím není
 *
 * Projekt  Ppp
 *   + Přidáno
 *   - Odebráno
 *   ~ Změněno
 *</pre>
 */
public class ZrnitostHodinCykly_143_
{    private ZrnitostHodinCykly_143_() {}   static
////////////////////////////////////////////////////////////////////////////////
//%X- ----- Konec přeskakovaného textu -----


/*******************************************************************************
 * Třída {@code ZrnitostHodinCykly} obsahuje několik statickým metod,
 * které testují zrnitost údajů systémových hodin a rychlost porcesoru.
 * Metody vypisují počet milisekund uplynuvších mezi dvěma tiky hodin
 * a současně také počet běhů cyklem mezi těmito tiky.
 * Většina metod provádí tento test opakovaně a tak názorně demonstruje
 * nerovnoměrnou rychlost zpracování programů.
 *
 * @author Rudolf PECINOVSKÝ
 * @version 6.03.2017 — 2010-11-08
 */
public class ZrnitostHodinCykly
{
//== KONSTANTNÍ ATRIBUTY TŘÍDY =================================================
//== PROMĚNNÉ ATRIBUTY TŘÍDY ===================================================
//== STATICKÝ INICIALIZAČNÍ BLOK - STATICKÝ KONSTRUKTOR ========================
//== KONSTANTNÍ ATRIBUTY INSTANCÍ ==============================================
//== PROMĚNNÉ ATRIBUTY INSTANCÍ ================================================
//== PŘÍSTUPOVÉ METODY VLASTNOSTÍ TŘÍDY ========================================
//== OSTATNÍ NESOUKROMÉ METODY TŘÍDY ===========================================

    /***************************************************************************
     * Jednorázový test využívající cyklus do.
     */
    public static void jednorázový_do()
    {
        long první = System.currentTimeMillis();
        int  dotaz = 0;
        long druhý;

        do{
            dotaz++;
            druhý = System.currentTimeMillis();
        }while( první == druhý );
        System.out.println("Tik " + (druhý-první) +
                           " ms po " + dotaz + ". čtení" );
    }


    /***************************************************************************
     * Zadaný počet krát změří dobu mezi dvěma tiky hodin a počet průchodů
     * cyklem, které za tu dobu program stihnul.
     *
     * @param pokusů Kolikrát budeme probíhat cyklem
     */
    public static void testZrnitostiHodin_while( int pokusů )
    {
        int  pokus = 0;
        long první = System.currentTimeMillis();
        long druhý = první;
        System.out.println("===== ZAČÁTEK TESTU ZRNITOSTI =====");
        while( ++pokus <= pokusů )
        {
            int  dotazů = 0;
            while (druhý == první) {
                dotazů++;
                druhý = System.currentTimeMillis();
            }
            System.out.println("Pokus "  + pokus  + ":  Tik=" + (druhý-první) +
                               " ms po " + dotazů + ". čtení");
            první = druhý;
        }
        System.out.println("===== KONEC TESTU ZRNITOSTI =====");
    }


    /***************************************************************************
     * Opakování jednorázového testu v cyklu while.
     *
     * @param pokusů Kolikrát budeme probíhat cyklem
     */
    public static void testHodin_while( int pokusů )
    {
        int pokus = 1;

        System.out.println("===== ZAČÁTEK TESTU WHILE =====");
        while( pokus <= pokusů )
        {
            System.out.print( "Pokus " + pokus + ": " );
            jednorázový_do();
            pokus++;
        }
        System.out.println("===== KONEC TESTU WHILE =====");
    }


    /***************************************************************************
     * Opakování jednorázového testu v cyklu for.
     *
     * @param pokusů Kolikrát budeme probíhat cyklem
     */
    public static void testHodin_for( int pokusů )
    {
        System.out.println("===== ZAČÁTEK TESTU FOR =====");
        for( int pokus = 1;   pokus <= pokusů;   pokus++ )
        {
            System.out.print( "Pokus " + pokus + ": " );
            jednorázový_do();
        }
//      System.out.println("Provedli jsme " + pokus + " pokusů" );
        System.out.println("===== KONEC TESTU FOR =====");
    }


    /***************************************************************************
     * Opakování jednorázového testu v nekonečném cyklu for(;;).
     */
    public static void nekonečný()
    {
        System.out.println("===== ZAČÁTEK NEKONEČNÉHO TESTU =====");
        for(;;)
        {
            jednorázový_do();
        }
    //      System.out.println("===== KONEC NEKONEČNÉHO TESTU =====");
    }


    /***************************************************************************
     * Sloučení obou předchozích testů do jediné metody.
     *
     * @param pokusů Kolikrát budeme probíhat cyklem
     */
    public static void testHodin_vnořený( int pokusů )
    {
        System.out.println("===== ZAČÁTEK TESTU S VNOŘENÝM CYKLEM =====");

        long minule = System.currentTimeMillis();

        for( int pokus = 1;   pokus <= pokusů;   pokus++ )
        {
            int  dotaz = 0;
            long nyní;

            do{
                dotaz++;
                nyní = System.currentTimeMillis();
            }while( nyní == minule );
            System.out.println("Pokus " + pokus +
                               ": tik " + (nyní-minule) +
                               " ms po " + dotaz + ". čtení" );
            minule = nyní;
        }
        System.out.println("===== KONEC TESTU S VNOŘENÝM CYKLEM =====");
    }


    /***************************************************************************
     * Sloučení obou předchozích testů do jediné metody.
     *
     * @param sekund Jak dlouho budeme probíhat cyklem
     */
    public static void testHodin_uprostřed( int sekund )
    {
        System.out.println("===== ZAČÁTEK TESTU S PEVNOU DOBOU MĚŘENÍ =====");

        long start  = System.currentTimeMillis();
        long minule = start;

        for(;;)
        {
            long nyní;
            int  dotaz = 0;

            do{
                nyní = System.currentTimeMillis();
                dotaz++;
            }while( nyní == minule );
            long měří_s = (int)((nyní - start)/1000);

            if( měří_s  >=  sekund ) {  //Podmínka testující setrvání v cyklu
                break;                  //Příkaz k ukončení cyklu
            }
            int měří_ms = (int)((nyní - start)%1000);
            System.out.println("Čas " + měří_s + "s, " + měří_ms +
                               "ms, tik " + (nyní-minule) +
                               " ms po " + dotaz + ". čtení" );
            minule = nyní;
        }
        System.out.println("===== KONEC TESTU S PEVNOU DOBOU MĚŘENÍ =====");
    }


    /***************************************************************************
     * Metoda ukazuje, že v některých případech může mít cyklus prázdné tělo.
     *
     * @param sekund Jak dlouho budeme probíhat cyklem
     */
    @SuppressWarnings("empty-statement")
    public static void testHodin_bezTěla( int sekund )
    {
        System.out.println("===== ZAČÁTEK TESTU S PRÁZDNÝM TĚLEM =====");
        long start  = System.currentTimeMillis();
        long minule = start;

        for(;;)
        {
            while( minule == System.currentTimeMillis() );
            long nyní = System.currentTimeMillis();
            long měří_s = (int)((nyní - start)/1000);

            if( měří_s  >=  sekund ) {  //Podmínka testující setrvání v cyklu
                break;                  //Příkaz k ukončení cyklu
            }
            int měří_ms = (int)((nyní - start)%1000);
            System.out.println("Čas " + měří_s + "s, " + měří_ms +
                               "ms, tik " + (nyní-minule) );
            minule = nyní;
        }
        System.out.println("===== KONEC TESTU S PRÁZDNÝM TĚLEM =====");
    }



//##############################################################################
//== KONSTRUKTORY A TOVÁRNÍ METODY =============================================

    /** Soukromy konstruktor bránící vytvoření instance. */
    private ZrnitostHodinCykly() {}


//== ABSTRAKTNÍ METODY =========================================================
//== PŘÍSTUPOVÉ METODY VLASTNOSTÍ INSTANCÍ =====================================
//== OSTATNÍ NESOUKROMÉ METODY INSTANCÍ ========================================
//== SOUKROMÉ A POMOCNÉ METODY TŘÍDY ===========================================
//== SOUKROMÉ A POMOCNÉ METODY INSTANCÍ ========================================
//== INTERNÍ DATOVÉ TYPY =======================================================
//== TESTY A METODA MAIN =======================================================

    /***************************************************************************
     * Testovací metoda.
     */
    public static void test()
    {
        ZrnitostHodinCykly.testZrnitostiHodin_while(100);
    }
//    /** @param args Parametry příkazového řádku - nepoužívané. */
//    public static void main( String[] args )  {  test();  }
}

//%%-  ----- Začátek ignorovaného závěrečného textu -----
////////////////////////////////////////////////////////////////////////////////
//== TESTY A METODA MAIN =======================================================

    /***************************************************************************
     * Testovací metoda.
     */
    public static void test()
    {
        ZrnitostHodinCykly.test();
//        IO.zpráva("Až se pokocháš, stiskni OK");
//        System.exit(0);
    }
    /** @param args Parametry příkazového řádku - nepoužívané. */
    public static void main( String[] args )  {  test();  }
}
